home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et3_0-a1.lha / et3 / src / Fields.C < prev    next >
C/C++ Source or Header  |  1992-08-24  |  18KB  |  846 lines
  1. #ifdef __GNUG__
  2. #pragma implementation
  3. #endif
  4.  
  5. #include "Fields.h"
  6.  
  7. #include "Class.h"
  8. #include "Look.h"
  9. #include "GapText.h"
  10. #include "Manager.h"
  11. #include "RegularExp.h"
  12. #include "Clipper.h"
  13. #include "TextView.h"
  14. #include "Alert_e.h"
  15. #include "Window.h"
  16. #include "Math.h"
  17.  
  18. //---- TextViewOverlay ---------------------------------------------------------
  19.  
  20. static TextViewOverlay *gTVO;
  21.  
  22. ONEXIT(Fields)
  23. {
  24.     SafeDelete(gTVO);
  25. }
  26.  
  27. TextViewOverlay::TextViewOverlay()
  28. {
  29.     currentfield= 0;
  30.     ct= 0;
  31.     cl= 0;
  32.     tv= 0;
  33.     noupdate= FALSE;
  34. }
  35.  
  36. TextViewOverlay::~TextViewOverlay()
  37. {
  38.     currentfield= 0;
  39.     if (ct) {
  40.     Object *op;
  41.     Iter next(ct->GetObserverIter());
  42.     while (op= next())
  43.         ct->RemoveObserver(op);
  44.     SafeDelete(ct);
  45.     }
  46.     SafeDelete(cl);
  47.     SafeDelete(tv);
  48. }
  49.  
  50. bool TextViewOverlay::CopyInStr(EditField *ef, char *buf, int sz)
  51. {
  52.     if (ef == currentfield) {
  53.     ct->CopyInStr((byte*)buf, sz, 0, ct->Size());
  54.     return FALSE;
  55.     }
  56.     return TRUE;
  57. }
  58.  
  59. bool TextViewOverlay::Size(EditField *ef, int *sz)
  60. {
  61.     if (ef == currentfield) {
  62.     *sz= ct->End();
  63.     return FALSE;
  64.     }
  65.     return TRUE;
  66. }
  67.  
  68. bool TextViewOverlay::KbdFocus(EditField *ef, bool in, bool wordwrap)
  69. {
  70.     if (gDebug)
  71.     fprintf(stderr, "TextViewOverlay::KbdFocus(0x%08x, %d) old:0x%08x\n",
  72.                             ef, in, currentfield);
  73.     if (in) {
  74.     if (currentfield != 0) {
  75.         if (gDebug)
  76.         fprintf(stderr, "KbdFocus(in): oops\n");
  77.         return FALSE;
  78.     }
  79.     if (ef)
  80.         ef->Reveal();
  81.     char *es= ef->GetStringForEditing();
  82.     currentfield= ef;
  83.     currentfield->SetFlag(eEditFieldHasOverlay);
  84.  
  85.     if (ct == 0) {
  86.         ct= new GapText((byte*)es);
  87.         tv= new TextView(currentfield, gFitRect, ct, TRUE);
  88.         tv->SetDragAndDrop(FALSE);
  89.         tv->SetFlag(eViewNoPrint);
  90.         tv->SetStopChars("\r\n");
  91.         tv->ResetFlag(eVObjKbdFocus);
  92.         cl= new Clipper(tv);
  93.         cl->Open();
  94.     } else {
  95.         ct->ReplaceWithStr((byte*)es);
  96.         cl->RevealRect(Rectangle(0,0,1,1), gPoint1);
  97.     }
  98.     //ct->SetFont(currentfield->GetFont(), 0, ct->Size());
  99.     ct->SetFont(currentfield->GetFont());
  100.     if (gToken.Code != eEvtLeftButton)
  101.         tv->SelectAll(FALSE);
  102.  
  103.     ct->AddObserver(currentfield);
  104.     cl->SetContainer(currentfield);
  105.     tv->SetNextHandler(currentfield);
  106.     //cl->Open();
  107.  
  108.     if (wordwrap)
  109.         tv->SetWordWrap(TRUE);
  110.  
  111.     currentfield->SetExtent(currentfield->GetExtent());
  112.     currentfield->SetOrigin(currentfield->GetOrigin());
  113.     currentfield->ForceRedraw();
  114.     } else {
  115.     if (currentfield != ef) {
  116.         if (gDebug) {
  117.         fprintf(stderr, "KbdFocus(out): oops %d\n", currentfield);
  118.         }
  119.         return FALSE;
  120.     }
  121.     if (!Sync(currentfield))
  122.         return FALSE;
  123.     tv->SetWordWrap(FALSE);
  124.     currentfield->ForceRedraw();
  125.     cl->ClearContainer(currentfield);
  126.     ct->RemoveObserver(currentfield);
  127.     currentfield->ResetFlag(eEditFieldHasOverlay);
  128.     currentfield= 0;
  129.     }
  130.     return tv->KbdFocus(in);
  131. }
  132.  
  133. bool TextViewOverlay::Sync(EditField *ef)
  134. {
  135.     if (currentfield == ef) {
  136.     char *tmp= ct->AsString();
  137.     noupdate= TRUE;
  138.     bool valid= currentfield->ValidateString(tmp);
  139.     noupdate= FALSE;
  140.     delete tmp;
  141.     if (! valid) {
  142.         ct->ReplaceWithStr((byte*)currentfield->GetStringForEditing());
  143.         cl->RevealRect(Rectangle(0,0,1,1), gPoint1);
  144.         tv->SelectAll(FALSE);
  145.         return FALSE;
  146.     }
  147.     return TRUE;
  148.     }
  149.     return FALSE;
  150. } 
  151.  
  152. bool TextViewOverlay::Draw(EditField *ef, Rectangle r)
  153. {
  154.     if (currentfield == ef) {
  155.     cl->DrawAll(r);
  156.     return FALSE;
  157.     }
  158.     return TRUE;
  159. }
  160.  
  161. void TextViewOverlay::Update(EditField *ef)
  162. {
  163.     if (currentfield == ef && !noupdate) {
  164.     ct->ReplaceWithStr((byte*)currentfield->GetStringForEditing());
  165.     //if (ct->GetFont() != currentfield->GetFont())
  166.         ct->SetFont(currentfield->GetFont());
  167.     cl->RevealRect(Rectangle(0,0,1,1), gPoint1);
  168.     }
  169. }
  170.  
  171. void TextViewOverlay::SetOrigin(EditField *ef, Point at)
  172. {
  173.     if (currentfield == ef)
  174.     cl->SetOrigin(at);
  175. }
  176.  
  177. void TextViewOverlay::SetExtent(EditField *ef, Point e)
  178. {
  179.     if (currentfield == ef) {
  180.     cl->SetExtent(e);
  181.     if (tv->GetWordWrap())
  182.         tv->SetExtent(Point(e.x, cFit));
  183.     }
  184. }
  185.  
  186. Command *TextViewOverlay::DispatchEvents(EditField *ef, Point lp, Token &t, Clipper *vf)
  187. {
  188.     if (currentfield == ef)
  189.     return cl->Input(lp, t, vf);
  190.     return 0;
  191. }
  192.  
  193. void TextViewOverlay::DoSetupMenu(EditField *ef, Menu *m)
  194. {
  195.     if (currentfield == ef)
  196.     tv->DoSetupMenu(m);
  197. }
  198.  
  199. Command *TextViewOverlay::DoMenuCommand(EditField *ef, int c)
  200. {
  201.     if (currentfield == ef)
  202.     return tv->DoMenuCommand(c);
  203.     return gNoChanges;
  204. }
  205.  
  206. //---- Field ----------------------------------------------------------------
  207.  
  208. NewMetaImpl(Field,VObject, (TP(font), T(minwidth)));
  209.  
  210. Field::Field(int mw, Font *f)
  211. {
  212.     Init(mw, f);
  213. }
  214.  
  215. Field::Field(int id, int mw, Font *f) : VObject(id)
  216. {
  217.     Init(mw, f);
  218. }
  219.  
  220. void Field::Init(int mw, Font *f)
  221. {
  222.     font= f;
  223.     minwidth= mw;
  224.     SetFlag(eVObjVFixed);
  225. }
  226.  
  227. void Field::SetEditable(bool e)
  228. {
  229.     SetFlag(eVObjKbdFocus, e);
  230.     SetFlag(eEditFieldNoBorder, !e);
  231. }
  232.  
  233. char *Field::GetStringForDrawing()
  234. {
  235.     return AsString();
  236. }
  237.  
  238. void Field::SetFont(Font *fp)
  239. {
  240.     font= fp;
  241. }
  242.  
  243. Metric Field::GetMinSize()
  244. {
  245.     int b= (int)gLook->FieldBorderLayout(TestFlag(eEditFieldNoBorder))->GetValue(this, 0);
  246.     return StaticTextView::MeasureText(GetStringForDrawing(), font, 
  247.                  minwidth, GetLines()).Expand(gBorder+Point(b));
  248. }
  249.  
  250. void Field::Draw(Rectangle)
  251. {
  252.     int b= (int)gLook->FieldBorderLayout(TestFlag(eEditFieldNoBorder))->GetValue(this, 0);
  253.     Ink *ink= Enabled() ? gInkBlack : gLook->DisableInk();
  254.     StaticTextView::DrawBoxedText(contentRect.Inset(gBorder+Point(b)),
  255.                   GetStringForDrawing(), font, ink, GetLines() > 1);
  256. }
  257.  
  258. int Field::Compare(Object *op)
  259. {
  260.     char *t1= AsString(), *t2= Guard(op,Field)->AsString();
  261.     return StrCmp((byte*)t1, (byte*)t2, -1, sortmap);
  262. }
  263.  
  264. bool Field::IsEqual(Object *op)
  265. {
  266.     if (op == 0 || ! op->IsKindOf(Field))
  267.     return FALSE;
  268.     byte *s1= (byte*)AsString(), *s2= (byte*)op->AsString();
  269.     if (s1 == 0 || s2 == 0)
  270.     return FALSE;
  271.     return StrCmp(s1, s2, -1, sortmap) == 0;
  272. }
  273.  
  274. int Field::GetLines()
  275. {
  276.     return 1;
  277. }
  278.  
  279. OStream& Field::PrintOn (OStream &s)
  280. {
  281.     VObject::PrintOn(s);
  282.     return s << font SP << minwidth SP;
  283. }
  284.  
  285. IStream& Field::ReadFrom(IStream &s)
  286. {
  287.     VObject::ReadFrom(s);
  288.     return s >> font >> minwidth;
  289. }
  290.  
  291. //---- EditField ---------------------------------------------------------------
  292.  
  293. NewMetaImpl0(EditField,Field);
  294.  
  295. EditField::EditField(int id, int mw, Font *f) : Field(id, mw, f)
  296. {
  297.     SetFlag(eVObjEnabled | eVObjKbdFocus);
  298. }
  299.  
  300. EditField::~EditField()
  301. {
  302.     //if (HasOverlay())
  303.     //    GetTextViewOverlay()->KbdFocus(this, FALSE, FALSE);
  304. }
  305.  
  306. TextViewOverlay *EditField::GetTextViewOverlay()
  307. {
  308.     Manager *m= (Manager*) FindNextHandlerOfClass(Meta(Manager));
  309.     if (m)
  310.     return m->GetTextViewOverlay();
  311.  
  312.     if (gDebug) {
  313.     fprintf(stderr, "EditField::GetTextViewOverlay\n");
  314.     if (GetNextHandler())
  315.         fprintf(stderr, "GetNextHandler(): %s\n", GetNextHandler()->ClassName());
  316.     else
  317.         fprintf(stderr, "GetNextHandler(): 0\n");
  318.     }
  319.  
  320.     if (gTVO == 0)
  321.     gTVO= new TextViewOverlay;
  322.     return gTVO;
  323. }
  324.  
  325. char *EditField::GetStringForEditing()
  326. {
  327.     return AsString();
  328. }
  329.  
  330. void EditField::Draw(Rectangle r)
  331. {
  332.     if (!HasOverlay() || GetTextViewOverlay()->Draw(this, r))
  333.     Field::Draw(r);
  334.     gLook->FieldBorderLayout(TestFlag(eEditFieldNoBorder))->Adorn(this, r, HasOverlay());
  335. }
  336.  
  337. void EditField::Update(bool redraw)
  338. {
  339.     if (HasOverlay())
  340.     GetTextViewOverlay()->Update(this);
  341.     if (redraw)
  342.     InvalidateRect(contentRect.Inset(gPoint4));
  343.     //ForceRedraw();
  344. }
  345.  
  346. void EditField::Sync()
  347. {
  348.     if (HasOverlay())
  349.     GetTextViewOverlay()->Sync(this);
  350. }
  351.  
  352. static bool lock;
  353.  
  354. void EditField::DoSetupMenu(Menu *m)
  355. {
  356.     if (HasOverlay() && !lock) {
  357.     lock= TRUE;
  358.     GetTextViewOverlay()->DoSetupMenu(this, m);
  359.     lock= FALSE;
  360.     } else
  361.     Field::DoSetupMenu(m);
  362. }
  363.  
  364. Command *EditField::DoMenuCommand(int c)
  365. {
  366.     if (HasOverlay() && !lock) {
  367.     lock= TRUE;
  368.     Command *cmd= GetTextViewOverlay()->DoMenuCommand(this, c);
  369.     lock= FALSE;
  370.     return cmd;
  371.     }
  372.     return Field::DoMenuCommand(c);
  373. }
  374.  
  375. Command *EditField::Input(Point lp, Token &t, Clipper *vf)
  376. {
  377.     if (t.IsKey()) {
  378.     if (t.Code == '\t') {
  379.         Manager *m= (Manager*) FindNextHandlerOfClass(Meta(Manager));
  380.         if (m)
  381.         m->TabFields(t);
  382.         return gNoChanges;
  383.     }
  384.     if ((t.Code == '\r' || t.Code == '\n') && GetLines() <= 1) {
  385.         Manager *m= (Manager*) FindNextHandlerOfClass(Meta(Manager));
  386.         if (m)
  387.         m->TabFields(t);
  388.         return gNoChanges;
  389.     }
  390.     }
  391.     return Field::Input(lp, t, vf);
  392. }
  393.  
  394. void EditField::SetOrigin(Point at)
  395. {
  396.     Field::SetOrigin(at);
  397.     if (HasOverlay()) {
  398.     int b= (int)gLook->FieldBorderLayout(TestFlag(eEditFieldNoBorder))->GetValue(this, 0);
  399.     GetTextViewOverlay()->SetOrigin(this, at+Point(b));
  400.     }
  401. }
  402.  
  403. void EditField::SetExtent(Point e)
  404. {
  405.     Field::SetExtent(e);
  406.     if (HasOverlay()) {
  407.     int b= (int)gLook->FieldBorderLayout(TestFlag(eEditFieldNoBorder))->GetValue(this, 0);
  408.     GetTextViewOverlay()->SetExtent(this, e-2*Point(b));
  409.     }
  410. }
  411.  
  412. bool EditField::KbdFocus(bool in)
  413. {
  414.     if (HasOverlay() != in)
  415.         return GetTextViewOverlay()->KbdFocus(this, in, GetLines() > 1);
  416.     return TRUE;
  417. }
  418.  
  419. void EditField::Control(int id, int part, void *val)
  420. {
  421.     switch (part) {
  422.     case cPartSelectionChanged:
  423.     case cPartViewSize:
  424.     case cPartOriginChanged:
  425.     case cPartExtentChanged:
  426.     case cPartScrollPos:
  427.     break;
  428.  
  429.     case cPartChangedText:
  430.     Field::Control(GetId(), part, val);
  431.     break;
  432.  
  433.     default:
  434.     if (gDebug)
  435.         fprintf(stderr, "EditField::Control(%d, %d, %d)\n", id, part, val);
  436.     Field::Control(id, part, val);
  437.     break;
  438.     }
  439. }
  440.  
  441. Command *EditField::DispatchEvents(Point lp, Token &t, Clipper *vf)
  442. {
  443.     Command *cmd;
  444.     if (HasOverlay() && (cmd= GetTextViewOverlay()->DispatchEvents(this, lp, t, vf)))
  445.     return cmd;
  446.     return Field::DispatchEvents(lp, t, vf);
  447. }
  448.  
  449. bool EditField::ValidateString(char*)
  450. {
  451.     // called when content in TextView needs to be checked, eg. focus loss
  452.     // override for validation, reformatting and completion of string
  453.     // return FALSE if not acceptable
  454.     return TRUE;
  455. }
  456.  
  457. void EditField::Open(bool mode)
  458. {
  459.     Field::Open(mode);
  460. }
  461.  
  462. //---- TextField ---------------------------------------------------------------
  463.  
  464. NewMetaImpl(TextField,EditField, (TP(text)));
  465.  
  466. TextField::TextField(int id, int minWidthInChars, Font *f) : EditField(id, 0, f)
  467. {
  468.     text= 0;
  469.     strreplace(&text, "");
  470.     minwidth= font->Width('w') * minWidthInChars;
  471. }
  472.  
  473. TextField::TextField(int id, int minWidthInPixel, char *t) : EditField(id, minWidthInPixel)
  474. {
  475.     text= 0;
  476.     if (t == 0)
  477.     t= "";
  478.     strreplace(&text, t);
  479. }
  480.  
  481. TextField::~TextField()
  482. {
  483.     SafeDelete(text);
  484. }
  485.  
  486. char *TextField::AsString()
  487. {
  488.     return text;
  489. }
  490.  
  491. void TextField::SetString(char *t, bool redraw)
  492. {
  493.     strreplace(&text, t);
  494.     Update(redraw);
  495.     Changed();
  496. }
  497.  
  498. void TextField::SetFString(bool redraw, char *va_(fmt), ...)
  499. {
  500.     va_list ap;
  501.     va_start(ap,va_(fmt));
  502.     strfreplace(&text, va_(fmt), ap);
  503.     Update(redraw);
  504.     Changed();
  505.     va_end(ap);
  506. }
  507.  
  508. void TextField::GetString(char *buf, int sz)
  509. {
  510.     if (!HasOverlay() || GetTextViewOverlay()->CopyInStr(this, buf, sz)) {
  511.     if (text)
  512.         strn0cpy(buf, text, sz);
  513.     else
  514.         strcpy(buf, "");
  515.     }
  516. }
  517.  
  518. char *TextField::GetString()
  519. {
  520.     Sync();
  521.     return AsString();
  522. }
  523.  
  524. int TextField::GetTextSize()
  525. {
  526.     int sz= 0;
  527.     if (!HasOverlay() || GetTextViewOverlay()->Size(this, &sz))
  528.     if (text)
  529.         sz= strlen(text);
  530.     return sz;
  531. }
  532.  
  533. OStream& TextField::PrintOn (OStream &s)
  534. {
  535.     EditField::PrintOn(s);
  536.     return s.PrintString(text);
  537. }
  538.  
  539. IStream& TextField::ReadFrom(IStream &s)
  540. {
  541.     char *t;
  542.     EditField::ReadFrom(s);
  543.     s.ReadString(&t);
  544.     SetString(t, FALSE);
  545.     return s;
  546. }
  547.  
  548. bool TextField::ValidateString(char *s)
  549. {
  550.     SetString(s, FALSE);
  551.     return TRUE;
  552. }
  553.  
  554. //---- MultiLineField ----------------------------------------------------------
  555.  
  556. NewMetaImpl(MultiLineField,TextField, (T(lines)));
  557.  
  558. MultiLineField::MultiLineField(int id, int l, int mw, char *t)
  559.                             : TextField(id, mw, t)
  560. {
  561.     lines= Math::Max(0, l);
  562. }
  563.     
  564. int MultiLineField::GetLines()
  565. {
  566.     return lines;
  567. }
  568.  
  569. OStream& MultiLineField::PrintOn (OStream &s)
  570. {
  571.     TextField::PrintOn(s);
  572.     return s << lines SP;
  573. }
  574.  
  575. IStream& MultiLineField::ReadFrom(IStream &s)
  576. {
  577.     TextField::ReadFrom(s);
  578.     return s >> lines;
  579. }
  580.  
  581. //---- FormatField -------------------------------------------------------------
  582.  
  583. NewMetaImpl(FormatField,EditField, (TP(format)));
  584.  
  585. FormatField::FormatField(int id, char *fmt) : EditField(id)
  586. {
  587.     format= strsave(fmt);
  588. }
  589.  
  590. FormatField::~FormatField()
  591. {
  592.     SafeDelete(format);
  593. }
  594.  
  595. OStream& FormatField::PrintOn(OStream &s)
  596. {
  597.     EditField::PrintOn(s);
  598.     return s.PrintString(format);
  599. }
  600.  
  601. IStream& FormatField::ReadFrom(IStream &s)
  602. {
  603.     EditField::ReadFrom(s);
  604.     SafeDelete(format);
  605.     return s.ReadString(&format);
  606. }
  607.  
  608. //---- IntField ----------------------------------------------------------------
  609.  
  610. NewMetaImpl(IntField,FormatField, (T(value), T(minVal), T(maxVal)));
  611.  
  612. IntField::IntField(int id, int mi, int ma, char *fmt) : FormatField(id, fmt)
  613. {
  614.     Init(0, mi, ma);
  615. }
  616.  
  617. IntField::IntField(int id, int val, int mi, int ma, char *fmt) : FormatField(id, fmt)
  618. {
  619.     Init(val, mi, ma);
  620. }
  621.  
  622. void IntField::Init(int val, int mi, int ma)
  623. {
  624.     minVal= mi;
  625.     maxVal= ma;
  626.     int lmin= font->Width((byte*)form(format, minVal));
  627.     int lmax= font->Width((byte*)form(format, maxVal));
  628.     minwidth= Math::Max(lmin, lmax);
  629.     SetValue(val, FALSE);
  630. }
  631.  
  632. char *IntField::AsString()
  633. {
  634.     return form(format, value);
  635. }
  636.  
  637. char *IntField::GetStringForDrawing()
  638. {
  639.     return form(format, value);
  640. }
  641.  
  642. int IntField::GetValue()
  643. {
  644.     Sync();
  645.     return value;
  646. }
  647.  
  648. bool IntField::SetValue(int newVal, bool redraw)
  649. {
  650.     newVal= Math::Range(minVal, maxVal, newVal);
  651.     if (newVal != value) {
  652.     value= newVal;
  653.     Update(redraw);
  654.     return TRUE;
  655.     }
  656.     return FALSE;
  657. }
  658.  
  659. void IntField::GetRange(int &mi, int &ma)
  660. {
  661.     mi= minVal;
  662.     ma= maxVal;
  663. }
  664.  
  665. void IntField::SetRange(int mi, int ma)
  666. {
  667.     minVal= mi;
  668.     maxVal= ma;
  669.     SetValue(value);
  670. }
  671.  
  672. OStream& IntField::PrintOn(OStream &s)
  673. {
  674.     FormatField::PrintOn(s);
  675.     return s << value SP << minVal SP << maxVal SP;
  676. }
  677.  
  678. IStream& IntField::ReadFrom(IStream &s)
  679. {
  680.     int newval;
  681.     FormatField::ReadFrom(s);
  682.     s >> newval >> minVal >> maxVal;
  683.     SetValue(newval, FALSE);
  684.     return s;
  685. }
  686.  
  687. bool IntField::ValidateString(char *s)
  688. {
  689.     int newval;
  690.     if (sscanf(s, "%d", &newval) != 1) {
  691.     ShowAlert(eAlertNote, "\"%s\" is not a number", s);
  692.     return FALSE;
  693.     }
  694.     
  695.     if (newval < minVal || newval > maxVal) {
  696.     ShowAlert(eAlertNote, "%d not in range %d-%d", newval, minVal, maxVal);
  697.     return FALSE;
  698.     }
  699.     if (SetValue(newval))
  700.     Control(GetId(), cPartValueChanged, &newval);
  701.     return TRUE;
  702. }
  703.  
  704. //---- FloatField ----------------------------------------------------------------
  705.  
  706. NewMetaImpl(FloatField,FormatField, (T(value), T(minVal), T(maxVal)));
  707.  
  708. FloatField::FloatField(int id, double mi, double ma, char *fmt) : FormatField(id, fmt)
  709. {
  710.     Init(0.0, mi, ma);
  711. }
  712.  
  713. FloatField::FloatField(int id, double val, double mi, double ma, char *fmt)
  714.                             : FormatField(id, fmt)
  715. {
  716.     Init(val, mi, ma);
  717. }
  718.  
  719. void FloatField::Init(double val, double mi, double ma)
  720. {
  721.     minVal= mi;
  722.     maxVal= ma;
  723.     int lmin= font->Width((byte*)form(format, minVal));
  724.     int lmax= font->Width((byte*)form(format, maxVal));
  725.     minwidth= Math::Max(lmin, lmax);
  726.     SetValue(val, FALSE);
  727. }
  728.  
  729. char *FloatField::AsString()
  730. {
  731.     return form(format, value);
  732. }
  733.  
  734. char *FloatField::GetStringForDrawing()
  735. {
  736.     return form(format, value);
  737. }
  738.  
  739. double FloatField::GetValue()
  740. {
  741.     Sync();
  742.     return value;
  743. }
  744.  
  745. bool FloatField::SetValue(double newVal, bool redraw)
  746. {
  747.     newVal= Math::Range(minVal, maxVal, newVal);
  748.     if (newVal != value) {
  749.     value= newVal;
  750.     Update(redraw);
  751.     return TRUE;
  752.     }
  753.     return FALSE;
  754. }
  755.  
  756. void FloatField::GetRange(double &mi, double &ma)
  757. {
  758.     mi= minVal;
  759.     ma= maxVal;
  760. }
  761.  
  762. void FloatField::SetRange(double mi, double ma)
  763. {
  764.     minVal= mi;
  765.     maxVal= ma;
  766.     SetValue(value);
  767. }
  768.  
  769. OStream& FloatField::PrintOn(OStream &s)
  770. {
  771.     FormatField::PrintOn(s);
  772.     return s << value SP << minVal SP << maxVal SP;
  773. }
  774.  
  775. IStream& FloatField::ReadFrom(IStream &s)
  776. {
  777.     double newval;
  778.     FormatField::ReadFrom(s);
  779.     s >> newval >> minVal >> maxVal;
  780.     SetValue(newval, FALSE);
  781.     return s;
  782. }
  783.  
  784. bool FloatField::ValidateString(char *s)
  785. {
  786.     double newval;
  787.     if (sscanf(s, "%lf", &newval) != 1) {
  788.     ShowAlert(eAlertNote, "\"%s\" is not a number", s);
  789.     return FALSE;
  790.     }
  791.     
  792.     if (newval < minVal || newval > maxVal) {
  793.     ShowAlert(eAlertNote, "%g not in range %g-%g", newval, minVal, maxVal);
  794.     return FALSE;
  795.     }
  796.     if (SetValue(newval))
  797.     Control(GetId(), cPartValueChanged, &newval);
  798.     return TRUE;
  799. }
  800.  
  801. //---- RegExpField ----------------------------------------------------------
  802.  
  803. NewMetaImpl(RegExpField,TextField, (TP(regex), TP(errmsg)));
  804.  
  805. RegExpField::RegExpField(int id, RegularExp *r, int mw, char *msg, char *t)
  806.                             : TextField(id, mw, t)
  807. {
  808.     regex= r;
  809.     if (msg == 0)
  810.     msg= "Illegal format \"%s\" ";
  811.     errmsg= 0;
  812.     strreplace(&errmsg, msg);
  813. }
  814.  
  815. RegExpField::~RegExpField()
  816. {
  817.     SafeDelete(regex);
  818.     SafeDelete(errmsg);
  819. }
  820.  
  821. bool RegExpField::ValidateString(char *s)
  822. {
  823.     TextField::ValidateString(s);
  824.     if (strlen(s) && regex->Match(s) != strlen(s)) {
  825.     ShowAlert(eAlertNote, errmsg, s);
  826.     return FALSE;
  827.     }
  828.     return TRUE;
  829. }
  830.  
  831. OStream& RegExpField::PrintOn(OStream &s)
  832. {
  833.     TextField::PrintOn(s);
  834.     s << regex SP;
  835.     return s.PrintString(errmsg);
  836. }
  837.  
  838. IStream& RegExpField::ReadFrom(IStream &s)
  839. {
  840.     TextField::ReadFrom(s);
  841.     s >> regex;
  842.     SafeDelete(errmsg);
  843.     return s.ReadString(&errmsg);
  844. }
  845.  
  846.